/**
 * 能力管理系统数据模型定义
 *
 * 本文件定义了能力管理系统的核心数据模型，包括：
 * - 能力定义模型
 * - 能力评估模型
 * - 能力组合模型
 * - 能力交易模型
 * - 能力监控模型
 */

// ==================== 基础枚举定义 ====================

/**
 * 能力分类枚举
 */
export enum CapabilityCategory {
  ANALYTICS = 'analytics', // 分析能力
  AUTOMATION = 'automation', // 自动化能力
  BUSINESS = 'business', // 业务能力
  COMMUNICATION = 'communication', // 通信能力
  INTEGRATION = 'integration', // 集成能力
  INTELLIGENCE = 'intelligence', // 智能能力
  SECURITY = 'security', // 安全能力
  TECHNICAL = 'technical', // 技术能力
}

/**
 * 能力类型枚举
 */
export enum CapabilityType {
  ALGORITHM = 'algorithm', // 算法能力
  API = 'api', // API能力
  FORM = 'form', // 表单能力
  FUNCTION = 'function', // 函数能力
  MODEL = 'model', // 模型能力
  PROCESS = 'process', // 流程能力
  REPORT = 'report', // 报表能力
  RULE = 'rule', // 规则能力
  SERVICE = 'service', // 服务能力
  WORKFLOW = 'workflow', // 工作流能力
}

/**
 * 能力状态枚举
 */
export enum CapabilityStatus {
  ACTIVE = 'active', // 启用
  ARCHIVED = 'archived', // 归档
  DEPRECATED = 'deprecated', // 废弃
  DRAFT = 'draft', // 草稿
  INACTIVE = 'inactive', // 禁用
}

/**
 * 能力生命周期枚举
 */
export enum CapabilityLifecycle {
  DEVELOPMENT = 'development', // 开发中
  MAINTENANCE = 'maintenance', // 维护中
  PRODUCTION = 'production', // 生产环境
  RETIREMENT = 'retirement', // 退役
  TESTING = 'testing', // 测试中
}

/**
 * 评估指标类型枚举
 */
export enum EvaluationMetricType {
  AVAILABILITY = 'availability', // 可用性指标
  BUSINESS = 'business', // 业务指标
  COMPATIBILITY = 'compatibility', // 兼容性指标
  FUNCTIONAL = 'functional', // 功能指标
  PERFORMANCE = 'performance', // 性能指标
  SECURITY = 'security', // 安全指标
}

/**
 * 组合关系类型枚举
 */
export enum CompositionRelationType {
  CONDITIONAL = 'conditional', // 条件关系
  EXCLUSIVE = 'exclusive', // 互斥关系
  LOOP = 'loop', // 循环关系
  PARALLEL = 'parallel', // 并行关系
  SEQUENTIAL = 'sequential', // 顺序关系
}

/**
 * 交易状态枚举
 */
export enum TradeStatus {
  APPROVED = 'approved', // 已批准
  CANCELLED = 'cancelled', // 已取消
  COMPLETED = 'completed', // 已完成
  PENDING = 'pending', // 待处理
  REJECTED = 'rejected', // 已拒绝
}

// ==================== 能力定义模型 ====================

/**
 * 能力定义接口
 */
export interface CapabilityDefinition {
  // 基本信息
  id: string; // 能力ID
  name: string; // 能力名称
  code: string; // 能力代码
  version: string; // 版本号
  category: CapabilityCategory; // 能力分类
  type: CapabilityType; // 能力类型

  // 描述信息
  description: string; // 能力描述
  tags: string[]; // 标签列表
  icon: string; // 图标
  owner: string; // 所有者

  // 能力规格
  specification: CapabilitySpecification; // 能力规格
  interfaces: CapabilityInterface[]; // 接口定义
  parameters: CapabilityParameter[]; // 参数定义

  // 能力约束
  preconditions: CapabilityPrecondition[]; // 前置条件
  postconditions: CapabilityPostcondition[]; // 后置条件
  constraints: CapabilityConstraint[]; // 约束条件

  // 能力实现
  implementation: CapabilityImplementation; // 实现信息
  executionModel: ExecutionModel; // 执行模型

  // 状态管理
  status: CapabilityStatus; // 能力状态
  lifecycle: CapabilityLifecycle; // 生命周期

  // 元数据
  metadata: CapabilityMetadata; // 元数据
  createdAt: string; // 创建时间
  updatedAt: string; // 更新时间
  createdBy: string; // 创建者
}

/**
 * 能力规格接口
 */
export interface CapabilitySpecification {
  version: string; // 规格版本
  inputs: DataSpecification[]; // 输入规格
  outputs: DataSpecification[]; // 输出规格
  behavior: BehaviorSpecification; // 行为规格
  quality: QualitySpecification; // 质量规格
}

/**
 * 数据规格接口
 */
export interface DataSpecification {
  name: string; // 数据名称
  type: string; // 数据类型
  description: string; // 数据描述
  required: boolean; // 是否必需
  defaultValue?: any; // 默认值
  validation?: ValidationRule[]; // 验证规则
}

/**
 * 行为规格接口
 */
export interface BehaviorSpecification {
  description: string; // 行为描述
  steps: BehaviorStep[]; // 行为步骤
  exceptions: ExceptionHandling[]; // 异常处理
  timeouts: TimeoutConfig; // 超时配置
}

/**
 * 质量规格接口
 */
export interface QualitySpecification {
  performance: PerformanceRequirement; // 性能要求
  reliability: ReliabilityRequirement; // 可靠性要求
  security: SecurityRequirement; // 安全要求
  availability: AvailabilityRequirement; // 可用性要求
}

/**
 * 能力接口定义
 */
export interface CapabilityInterface {
  name: string; // 接口名称
  method: string; // 接口方法
  path: string; // 接口路径
  description: string; // 接口描述
  parameters: InterfaceParameter[]; // 接口参数
  responses: InterfaceResponse[]; // 接口响应
}

/**
 * 能力参数定义
 */
export interface CapabilityParameter {
  name: string; // 参数名称
  type: string; // 参数类型
  description: string; // 参数描述
  required: boolean; // 是否必需
  defaultValue?: any; // 默认值
  validation?: ValidationRule[]; // 验证规则
}

/**
 * 能力前置条件
 */
export interface CapabilityPrecondition {
  id: string; // 条件ID
  name: string; // 条件名称
  description: string; // 条件描述
  expression: string; // 条件表达式
  priority: number; // 优先级
  enabled: boolean; // 是否启用
}

/**
 * 能力后置条件
 */
export interface CapabilityPostcondition {
  id: string; // 条件ID
  name: string; // 条件名称
  description: string; // 条件描述
  expression: string; // 条件表达式
  validation: ValidationRule[]; // 验证规则
  enabled: boolean; // 是否启用
}

/**
 * 能力约束条件
 */
export interface CapabilityConstraint {
  id: string; // 约束ID
  name: string; // 约束名称
  description: string; // 约束描述
  type: ConstraintType; // 约束类型
  expression: string; // 约束表达式
  severity: ConstraintSeverity; // 约束严重程度
  enabled: boolean; // 是否启用
}

/**
 * 能力实现信息
 */
export interface CapabilityImplementation {
  language: string; // 实现语言
  framework: string; // 实现框架
  repository: string; // 代码仓库
  entryPoint: string; // 入口点
  dependencies: string[]; // 依赖列表
  configuration: Record<string, any>; // 配置信息
}

/**
 * 执行模型
 */
export interface ExecutionModel {
  type: ExecutionType; // 执行类型
  mode: ExecutionMode; // 执行模式
  timeout: number; // 超时时间
  retry: RetryConfig; // 重试配置
  circuitBreaker: CircuitBreakerConfig; // 熔断配置
}

/**
 * 能力元数据
 */
export interface CapabilityMetadata {
  version: string; // 元数据版本
  schema: string; // 数据模式
  namespace: string; // 命名空间
  tags: Record<string, string>; // 标签映射
  annotations: Record<string, any>; // 注解信息
}

// ==================== 能力评估模型 ====================

/**
 * 能力评估结果接口
 */
export interface EvaluationResult {
  id: string; // 评估ID
  capabilityId: string; // 能力ID
  evaluationDate: string; // 评估日期
  evaluator: string; // 评估者

  // 综合评分
  overallScore: number; // 综合评分

  // 分项评分
  scores: {
    availability: number; // 可用性评分
    business: number; // 业务评分
    compatibility: number; // 兼容性评分
    functional: number; // 功能评分
    performance: number; // 性能评分
    security: number; // 安全评分
  };

  // 评估详情
  details: {
    availability: AvailabilityAssessment; // 可用性评估
    business: BusinessAssessment; // 业务评估
    compatibility: CompatibilityAssessment; // 兼容性评估
    functional: FunctionalAssessment; // 功能评估
    performance: PerformanceAssessment; // 性能评估
    security: SecurityAssessment; // 安全评估
  };

  // 改进建议
  recommendations: Recommendation[]; // 改进建议

  // 趋势分析
  trends: TrendAnalysis; // 趋势分析
}

/**
 * 功能评估接口
 */
export interface FunctionalAssessment {
  completeness: number; // 功能完整度
  correctness: number; // 功能正确性
  coverage: number; // 测试覆盖率
  reliability: number; // 功能可靠性
  details: FunctionalTestResult[]; // 功能测试结果
}

/**
 * 性能评估接口
 */
export interface PerformanceAssessment {
  responseTime: {
    average: number; // 平均响应时间
    p95: number; // 95%响应时间
    p99: number; // 99%响应时间
  };
  throughput: {
    max: number; // 最大吞吐量
    stable: number; // 稳定吞吐量
  };
  resourceUsage: {
    cpu: number; // CPU使用率
    disk: number; // 磁盘使用率
    memory: number; // 内存使用率
    network: number; // 网络使用率
  };
  details: PerformanceTestResult[]; // 性能测试结果
}

/**
 * 安全评估接口
 */
export interface SecurityAssessment {
  vulnerabilityScore: number; // 漏洞评分
  complianceScore: number; // 合规评分
  encryptionLevel: number; // 加密等级
  accessControl: number; // 访问控制评分
  details: SecurityTestResult[]; // 安全测试结果
}

/**
 * 可用性评估接口
 */
export interface AvailabilityAssessment {
  uptime: number; // 可用时间
  errorRate: number; // 错误率
  recoveryTime: number; // 恢复时间
  userSatisfaction: number; // 用户满意度
  details: AvailabilityTestResult[]; // 可用性测试结果
}

/**
 * 兼容性评估接口
 */
export interface CompatibilityAssessment {
  platformCompatibility: number; // 平台兼容性
  versionCompatibility: number; // 版本兼容性
  integrationEase: number; // 集成便利性
  apiStability: number; // API稳定性
  details: CompatibilityTestResult[]; // 兼容性测试结果
}

/**
 * 业务评估接口
 */
export interface BusinessAssessment {
  businessValue: number; // 业务价值
  costEffectiveness: number; // 成本效益
  marketDemand: number; // 市场需求
  competitiveAdvantage: number; // 竞争优势
  details: BusinessTestResult[]; // 业务测试结果
}

/**
 * 改进建议接口
 */
export interface Recommendation {
  id: string; // 建议ID
  title: string; // 建议标题
  description: string; // 建议描述
  priority: RecommendationPriority; // 建议优先级
  impact: string; // 影响范围
  effort: string; // 工作量
  improvement: number; // 预期提升
  actionItems: ActionItem[]; // 行动项
}

/**
 * 趋势分析接口
 */
export interface TrendAnalysis {
  scoreHistory: ScoreHistory[]; // 评分历史
  improvementRate: number; // 改进率
  trendDirection: TrendDirection; // 趋势方向
  predictions: Prediction[]; // 预测结果
}

// ==================== 能力组合模型 ====================

/**
 * 能力组合接口
 */
export interface CapabilityComposition {
  id: string; // 组合ID
  name: string; // 组合名称
  description: string; // 组合描述

  // 组合结构
  components: ComposedCapability[]; // 组合组件
  relationships: CapabilityRelationship[]; // 组件关系

  // 组合配置
  configuration: CompositionConfiguration; // 组合配置
  orchestration: OrchestrationRules; // 编排规则

  // 执行配置
  executionConfig: ExecutionConfiguration; // 执行配置
  monitoringConfig: MonitoringConfiguration; // 监控配置

  // 状态管理
  status: CompositionStatus; // 组合状态
  version: string; // 版本号

  // 元数据
  metadata: CompositionMetadata; // 元数据
  createdAt: string; // 创建时间
  updatedAt: string; // 更新时间
  createdBy: string; // 创建者
}

/**
 * 组合组件接口
 */
export interface ComposedCapability {
  id: string; // 组件ID
  capabilityId: string; // 能力ID
  name: string; // 组件名称
  role: string; // 组件角色
  configuration: Record<string, any>; // 组件配置
  parameters: ParameterMapping[]; // 参数映射
}

/**
 * 能力关系接口
 */
export interface CapabilityRelationship {
  id: string; // 关系ID
  sourceId: string; // 源组件ID
  targetId: string; // 目标组件ID
  type: CompositionRelationType; // 关系类型
  condition?: string; // 条件表达式
  configuration: Record<string, any>; // 关系配置
}

/**
 * 组合配置接口
 */
export interface CompositionConfiguration {
  version: string; // 配置版本
  parameters: CompositionParameter[]; // 组合参数
  constraints: CompositionConstraint[]; // 组合约束
  optimization: OptimizationConfig; // 优化配置
}

/**
 * 编排规则接口
 */
export interface OrchestrationRules {
  version: string; // 规则版本
  rules: OrchestrationRule[]; // 编排规则
  policies: OrchestrationPolicy[]; // 编排策略
  schedules: OrchestrationSchedule[]; // 编排调度
}

// ==================== 能力交易模型 ====================

/**
 * 能力发布接口
 */
export interface CapabilityPublication {
  id: string; // 发布ID
  capabilityId: string; // 能力ID
  publisher: string; // 发布者
  title: string; // 发布标题
  description: string; // 发布描述

  // 发布信息
  version: string; // 发布版本
  category: string; // 发布分类
  tags: string[]; // 发布标签

  // 定价信息
  pricing: PricingModel; // 定价模型
  license: LicenseModel; // 许可模型

  // 发布状态
  status: PublicationStatus; // 发布状态
  publishDate: string; // 发布日期
  updateDate: string; // 更新日期
}

/**
 * 能力订阅接口
 */
export interface CapabilitySubscription {
  id: string; // 订阅ID
  publicationId: string; // 发布ID
  subscriber: string; // 订阅者
  subscriptionDate: string; // 订阅日期

  // 订阅配置
  configuration: SubscriptionConfig; // 订阅配置
  parameters: SubscriptionParameter[]; // 订阅参数

  // 订阅状态
  status: SubscriptionStatus; // 订阅状态
  startDate: string; // 开始日期
  endDate: string; // 结束日期
  autoRenew: boolean; // 自动续费
}

/**
 * 能力交易接口
 */
export interface CapabilityTrade {
  id: string; // 交易ID
  publicationId: string; // 发布ID
  buyer: string; // 买方
  seller: string; // 卖方
  tradeDate: string; // 交易日期

  // 交易信息
  amount: number; // 交易金额
  currency: string; // 交易货币
  quantity: number; // 交易数量

  // 交易状态
  status: TradeStatus; // 交易状态
  paymentStatus: PaymentStatus; // 支付状态
  deliveryStatus: DeliveryStatus; // 交付状态
}

// ==================== 能力监控模型 ====================

/**
 * 能力监控接口
 */
export interface CapabilityMonitoring {
  id: string; // 监控ID
  capabilityId: string; // 能力ID
  monitorType: MonitorType; // 监控类型

  // 监控配置
  configuration: MonitorConfiguration; // 监控配置
  thresholds: MonitorThreshold[]; // 监控阈值
  alerts: MonitorAlert[]; // 监控告警

  // 监控数据
  metrics: MonitorMetric[]; // 监控指标
  logs: MonitorLog[]; // 监控日志
  events: MonitorEvent[]; // 监控事件

  // 监控状态
  status: MonitorStatus; // 监控状态
  lastUpdate: string; // 最后更新
  health: MonitorHealth; // 监控健康度
}

/**
 * 监控指标接口
 */
export interface MonitorMetric {
  id: string; // 指标ID
  name: string; // 指标名称
  type: MetricType; // 指标类型
  value: number; // 指标值
  unit: string; // 指标单位
  timestamp: string; // 时间戳
  tags: Record<string, string>; // 指标标签
}

/**
 * 监控告警接口
 */
export interface MonitorAlert {
  id: string; // 告警ID
  name: string; // 告警名称
  severity: AlertSeverity; // 告警严重程度
  message: string; // 告警消息
  condition: string; // 告警条件
  timestamp: string; // 告警时间
  status: AlertStatus; // 告警状态
  actions: AlertAction[]; // 告警动作
}

// ==================== 辅助类型定义 ====================

/**
 * 约束类型枚举
 */
export enum ConstraintType {
  BUSINESS = 'business', // 业务约束
  FUNCTIONAL = 'functional', // 功能约束
  PERFORMANCE = 'performance', // 性能约束
  SECURITY = 'security', // 安全约束
}

/**
 * 约束严重程度枚举
 */
export enum ConstraintSeverity {
  CRITICAL = 'critical', // 严重
  HIGH = 'high', // 高
  LOW = 'low', // 低
  MEDIUM = 'medium', // 中
}

/**
 * 执行类型枚举
 */
export enum ExecutionType {
  ASYNCHRONOUS = 'asynchronous', // 异步执行
  BATCH = 'batch', // 批量执行
  STREAM = 'stream', // 流式执行
  SYNCHRONOUS = 'synchronous', // 同步执行
}

/**
 * 执行模式枚举
 */
export enum ExecutionMode {
  EVENT_DRIVEN = 'event_driven', // 事件驱动
  REPEATED = 'repeated', // 重复执行
  SCHEDULED = 'scheduled', // 定时执行
  SINGLE = 'single', // 单次执行
}

/**
 * 建议优先级枚举
 */
export enum RecommendationPriority {
  CRITICAL = 'critical', // 紧急
  HIGH = 'high', // 高优先级
  LOW = 'low', // 低优先级
  MEDIUM = 'medium', // 中优先级
}

/**
 * 趋势方向枚举
 */
export enum TrendDirection {
  DECLINING = 'declining', // 下降
  FLUCTUATING = 'fluctuating', // 波动
  IMPROVING = 'improving', // 改善
  STABLE = 'stable', // 稳定
}

/**
 * 发布状态枚举
 */
export enum PublicationStatus {
  ARCHIVED = 'archived', // 已归档
  DRAFT = 'draft', // 草稿
  PUBLISHED = 'published', // 已发布
  SUSPENDED = 'suspended', // 已暂停
}

/**
 * 订阅状态枚举
 */
export enum SubscriptionStatus {
  ACTIVE = 'active', // 活跃
  CANCELLED = 'cancelled', // 取消
  EXPIRED = 'expired', // 过期
  SUSPENDED = 'suspended', // 暂停
}

/**
 * 支付状态枚举
 */
export enum PaymentStatus {
  FAILED = 'failed', // 支付失败
  PAID = 'paid', // 已支付
  PENDING = 'pending', // 待支付
  REFUNDED = 'refunded', // 已退款
}

/**
 * 交付状态枚举
 */
export enum DeliveryStatus {
  DELIVERED = 'delivered', // 已交付
  FAILED = 'failed', // 交付失败
  PENDING = 'pending', // 待交付
  RETURNED = 'returned', // 已退回
}

/**
 * 监控类型枚举
 */
export enum MonitorType {
  AVAILABILITY = 'availability', // 可用性监控
  BUSINESS = 'business', // 业务监控
  PERFORMANCE = 'performance', // 性能监控
  SECURITY = 'security', // 安全监控
}

/**
 * 指标类型枚举
 */
export enum MetricType {
  COUNTER = 'counter', // 计数器
  GAUGE = 'gauge', // 仪表
  HISTOGRAM = 'histogram', // 直方图
  SUMMARY = 'summary', // 摘要
}

/**
 * 告警严重程度枚举
 */
export enum AlertSeverity {
  CRITICAL = 'critical', // 严重
  ERROR = 'error', // 错误
  INFO = 'info', // 信息
  WARNING = 'warning', // 警告
}

/**
 * 告警状态枚举
 */
export enum AlertStatus {
  ACKNOWLEDGED = 'acknowledged', // 已确认
  ACTIVE = 'active', // 活跃
  CLOSED = 'closed', // 已关闭
  RESOLVED = 'resolved', // 已解决
}

// ==================== 配置接口定义 ====================

/**
 * 重试配置接口
 */
export interface RetryConfig {
  maxAttempts: number; // 最大重试次数
  initialDelay: number; // 初始延迟时间
  maxDelay: number; // 最大延迟时间
  multiplier: number; // 延迟倍数
  retryableExceptions: string[]; // 可重试异常
}

/**
 * 熔断配置接口
 */
export interface CircuitBreakerConfig {
  failureThreshold: number; // 失败阈值
  recoveryTimeout: number; // 恢复超时
  halfOpenMaxAttempts: number; // 半开最大尝试次数
  failureRateThreshold: number; // 失败率阈值
}

/**
 * 验证规则接口
 */
export interface ValidationRule {
  type: string; // 规则类型
  expression: string; // 规则表达式
  message: string; // 错误消息
  severity: string; // 严重程度
}

/**
 * 行为步骤接口
 */
export interface BehaviorStep {
  id: string; // 步骤ID
  name: string; // 步骤名称
  description: string; // 步骤描述
  action: string; // 执行动作
  parameters: Record<string, any>; // 执行参数
  order: number; // 执行顺序
}

/**
 * 异常处理接口
 */
export interface ExceptionHandling {
  exceptionType: string; // 异常类型
  handler: string; // 处理器
  action: string; // 处理动作
  parameters: Record<string, any>; // 处理参数
}

/**
 * 超时配置接口
 */
export interface TimeoutConfig {
  default: number; // 默认超时
  perStep: Record<string, number>; // 每步超时
  maxTotal: number; // 最大总超时
}

/**
 * 性能要求接口
 */
export interface PerformanceRequirement {
  responseTime: number; // 响应时间要求
  throughput: number; // 吞吐量要求
  concurrency: number; // 并发要求
  resourceUsage: ResourceUsageLimit; // 资源使用限制
}

/**
 * 可靠性要求接口
 */
export interface ReliabilityRequirement {
  availability: number; // 可用性要求
  errorRate: number; // 错误率要求
  recoveryTime: number; // 恢复时间要求
  faultTolerance: string; // 容错能力
}

/**
 * 安全要求接口
 */
export interface SecurityRequirement {
  authentication: string; // 认证要求
  authorization: string; // 授权要求
  encryption: string; // 加密要求
  audit: string; // 审计要求
}

/**
 * 可用性要求接口
 */
export interface AvailabilityRequirement {
  uptime: number; // 可用时间要求
  maintenance: MaintenanceWindow; // 维护窗口
  backup: BackupRequirement; // 备份要求
  disaster: DisasterRecovery; // 灾难恢复
}

/**
 * 资源使用限制接口
 */
export interface ResourceUsageLimit {
  cpu: number; // CPU限制
  memory: number; // 内存限制
  disk: number; // 磁盘限制
  network: number; // 网络限制
}

/**
 * 维护窗口接口
 */
export interface MaintenanceWindow {
  schedule: string; // 维护计划
  duration: number; // 维护时长
  notification: string; // 通知方式
}

/**
 * 备份要求接口
 */
export interface BackupRequirement {
  frequency: string; // 备份频率
  retention: number; // 保留时间
  location: string; // 备份位置
}

/**
 * 灾难恢复接口
 */
export interface DisasterRecovery {
  rto: number; // 恢复时间目标
  rpo: number; // 恢复点目标
  strategy: string; // 恢复策略
}

/**
 * 接口参数接口
 */
export interface InterfaceParameter {
  name: string; // 参数名称
  type: string; // 参数类型
  required: boolean; // 是否必需
  description: string; // 参数描述
  defaultValue?: any; // 默认值
}

/**
 * 接口响应接口
 */
export interface InterfaceResponse {
  code: number; // 响应代码
  description: string; // 响应描述
  schema: string; // 响应模式
  examples: Record<string, any>; // 响应示例
}

/**
 * 参数映射接口
 */
export interface ParameterMapping {
  source: string; // 源参数
  target: string; // 目标参数
  transformation?: string; // 转换规则
  defaultValue?: any; // 默认值
}

/**
 * 组合参数接口
 */
export interface CompositionParameter {
  name: string; // 参数名称
  type: string; // 参数类型
  description: string; // 参数描述
  required: boolean; // 是否必需
  defaultValue?: any; // 默认值
}

/**
 * 组合约束接口
 */
export interface CompositionConstraint {
  id: string; // 约束ID
  name: string; // 约束名称
  description: string; // 约束描述
  expression: string; // 约束表达式
  severity: ConstraintSeverity; // 约束严重程度
}

/**
 * 优化配置接口
 */
export interface OptimizationConfig {
  performance: boolean; // 性能优化
  resource: boolean; // 资源优化
  cost: boolean; // 成本优化
  quality: boolean; // 质量优化
}

/**
 * 编排规则接口
 */
export interface OrchestrationRule {
  id: string; // 规则ID
  name: string; // 规则名称
  description: string; // 规则描述
  condition: string; // 规则条件
  action: string; // 规则动作
  priority: number; // 规则优先级
}

/**
 * 编排策略接口
 */
export interface OrchestrationPolicy {
  id: string; // 策略ID
  name: string; // 策略名称
  description: string; // 策略描述
  type: string; // 策略类型
  configuration: Record<string, any>; // 策略配置
}

/**
 * 编排调度接口
 */
export interface OrchestrationSchedule {
  id: string; // 调度ID
  name: string; // 调度名称
  description: string; // 调度描述
  cron: string; // Cron表达式
  enabled: boolean; // 是否启用
}

/**
 * 执行配置接口
 */
export interface ExecutionConfiguration {
  mode: ExecutionMode; // 执行模式
  timeout: number; // 执行超时
  retry: RetryConfig; // 重试配置
  circuitBreaker: CircuitBreakerConfig; // 熔断配置
}

/**
 * 监控配置接口
 */
export interface MonitoringConfiguration {
  enabled: boolean; // 是否启用
  metrics: string[]; // 监控指标
  intervals: Record<string, number>; // 监控间隔
  retention: number; // 数据保留时间
}

/**
 * 组合元数据接口
 */
export interface CompositionMetadata {
  version: string; // 元数据版本
  schema: string; // 数据模式
  namespace: string; // 命名空间
  tags: Record<string, string>; // 标签映射
  annotations: Record<string, any>; // 注解信息
}

/**
 * 定价模型接口
 */
export interface PricingModel {
  type: string; // 定价类型
  basePrice: number; // 基础价格
  currency: string; // 货币单位
  unit: string; // 计费单位
  tiers: PricingTier[]; // 价格层级
}

/**
 * 许可模型接口
 */
export interface LicenseModel {
  type: string; // 许可类型
  duration: number; // 许可时长
  unit: string; // 时长单位
  restrictions: string[]; // 使用限制
  permissions: string[]; // 使用权限
}

/**
 * 订阅配置接口
 */
export interface SubscriptionConfig {
  plan: string; // 订阅计划
  features: string[]; // 订阅功能
  limits: Record<string, number>; // 使用限制
  notifications: string[]; // 通知设置
}

/**
 * 订阅参数接口
 */
export interface SubscriptionParameter {
  name: string; // 参数名称
  value: any; // 参数值
  type: string; // 参数类型
  description: string; // 参数描述
}

/**
 * 监控配置接口
 */
export interface MonitorConfiguration {
  enabled: boolean; // 是否启用
  interval: number; // 监控间隔
  timeout: number; // 监控超时
  retries: number; // 重试次数
}

/**
 * 监控阈值接口
 */
export interface MonitorThreshold {
  metric: string; // 监控指标
  operator: string; // 比较操作符
  value: number; // 阈值数值
  severity: AlertSeverity; // 告警严重程度
}

/**
 * 监控健康度接口
 */
export interface MonitorHealth {
  status: string; // 健康状态
  score: number; // 健康评分
  issues: string[]; // 健康问题
  lastCheck: string; // 最后检查时间
}

/**
 * 告警动作接口
 */
export interface AlertAction {
  type: string; // 动作类型
  target: string; // 动作目标
  parameters: Record<string, any>; // 动作参数
  enabled: boolean; // 是否启用
}

/**
 * 行动项接口
 */
export interface ActionItem {
  id: string; // 行动项ID
  title: string; // 行动项标题
  description: string; // 行动项描述
  assignee: string; // 负责人
  dueDate: string; // 截止日期
  status: string; // 状态
}

/**
 * 评分历史接口
 */
export interface ScoreHistory {
  date: string; // 评分日期
  score: number; // 评分值
  category: string; // 评分类别
  details: Record<string, any>; // 评分详情
}

/**
 * 预测结果接口
 */
export interface Prediction {
  date: string; // 预测日期
  value: number; // 预测值
  confidence: number; // 置信度
  factors: string[]; // 影响因素
}

/**
 * 价格层级接口
 */
export interface PricingTier {
  min: number; // 最小数量
  max: number; // 最大数量
  price: number; // 单价
  discount: number; // 折扣
}

/**
 * 功能测试结果接口
 */
export interface FunctionalTestResult {
  testCase: string; // 测试用例
  status: string; // 测试状态
  duration: number; // 执行时长
  result: any; // 测试结果
  error?: string; // 错误信息
}

/**
 * 性能测试结果接口
 */
export interface PerformanceTestResult {
  testScenario: string; // 测试场景
  responseTime: number; // 响应时间
  throughput: number; // 吞吐量
  errorRate: number; // 错误率
  resourceUsage: Record<string, number>; // 资源使用
}

/**
 * 安全测试结果接口
 */
export interface SecurityTestResult {
  testType: string; // 测试类型
  vulnerability: string; // 漏洞类型
  severity: string; // 严重程度
  description: string; // 漏洞描述
  recommendation: string; // 修复建议
}

/**
 * 可用性测试结果接口
 */
export interface AvailabilityTestResult {
  testPeriod: string; // 测试周期
  uptime: number; // 可用时间
  downtime: number; // 停机时间
  incidents: number; // 故障次数
  mttr: number; // 平均修复时间
}

/**
 * 兼容性测试结果接口
 */
export interface CompatibilityTestResult {
  platform: string; // 测试平台
  version: string; // 平台版本
  status: string; // 兼容状态
  issues: string[]; // 兼容问题
  workarounds: string[]; // 解决方案
}

/**
 * 业务测试结果接口
 */
export interface BusinessTestResult {
  scenario: string; // 业务场景
  success: boolean; // 是否成功
  value: number; // 业务价值
  cost: number; // 业务成本
  roi: number; // 投资回报率
}

/**
 * 监控日志接口
 */
export interface MonitorLog {
  id: string; // 日志ID
  timestamp: string; // 时间戳
  level: string; // 日志级别
  message: string; // 日志消息
  context: Record<string, any>; // 日志上下文
}

/**
 * 监控事件接口
 */
export interface MonitorEvent {
  id: string; // 事件ID
  timestamp: string; // 时间戳
  type: string; // 事件类型
  source: string; // 事件源
  data: Record<string, any>; // 事件数据
}

/**
 * 组合状态枚举
 */
export enum CompositionStatus {
  ACTIVE = 'active', // 活跃
  ARCHIVED = 'archived', // 归档
  DRAFT = 'draft', // 草稿
  SUSPENDED = 'suspended', // 暂停
}

/**
 * 监控状态枚举
 */
export enum MonitorStatus {
  ACTIVE = 'active', // 活跃
  DISABLED = 'disabled', // 禁用
  PAUSED = 'paused', // 暂停
}

export default {
  CapabilityCategory,
  CapabilityType,
  CapabilityStatus,
  CapabilityLifecycle,
  EvaluationMetricType,
  CompositionRelationType,
  TradeStatus,
};
